{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "##进行xgboost的训练\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "import gc\n",
    "import csv\n",
    "import time \n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import OneHotEncoder,LabelEncoder\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn import metrics\n",
    "\n",
    "from sklearn.externals import joblib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_train = './out_put/encode_data_train.csv'\n",
    "file_vali = './out_put/encode_data_vali.csv'\n",
    "file_test = './out_put/encode_data_test.csv'\n",
    "\n",
    "df_train = pd.read_csv(file_train, index_col = 0)\n",
    "df_vali = pd.read_csv(file_vali, index_col = 0)\n",
    "df_test = pd.read_csv(file_test, index_col = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "##数据准备\n",
    "y_train = df_train['click']\n",
    "x_train = df_train.iloc[:,1:]\n",
    "\n",
    "y_vali = df_vali['click']\n",
    "x_vali = df_vali.iloc[:,1:]\n",
    "\n",
    "y_test = df_test['click']\n",
    "x_test = df_test.iloc[:,1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Begin Time : 2020-02-01 21:19:03\n",
      "[0]\tvalidation_0-auc:0.663951\n",
      "Will train until validation_0-auc hasn't improved in 10 rounds.\n",
      "[1]\tvalidation_0-auc:0.669895\n",
      "[2]\tvalidation_0-auc:0.670909\n",
      "[3]\tvalidation_0-auc:0.671622\n",
      "[4]\tvalidation_0-auc:0.673234\n",
      "[5]\tvalidation_0-auc:0.675165\n",
      "[6]\tvalidation_0-auc:0.675224\n",
      "[7]\tvalidation_0-auc:0.682689\n",
      "[8]\tvalidation_0-auc:0.684437\n",
      "[9]\tvalidation_0-auc:0.687103\n",
      "End Time : 2020-02-01 21:19:09\n"
     ]
    }
   ],
   "source": [
    "##进行xgboost拟合\n",
    "begin_time = time.time()\n",
    "print(f'Begin Time : {time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(begin_time))}')\n",
    "\n",
    "##受限于机器的资源，这里就不做gridsearch调参了，直接凑合着来(按最小资源消耗来设置参数)\n",
    "model = XGBClassifier(learning_rate=0.1\n",
    "                     ,n_estimators=10\n",
    "                     ,max_depth=3\n",
    "                     ,scale_pos_weight=1\n",
    "                     ,min_child_weight=1\n",
    "                     ,gamma=0\n",
    "                     ,subsample=1\n",
    "                     ,colsample_bylevel=1\n",
    "                     ,objective='binary:logistic'\n",
    "                     ,n_jobs=4\n",
    "                     ,seed=100)\n",
    "\n",
    "eval_set = [(x_vali, y_vali)]\n",
    "model.fit(x_train, y_train, eval_metric=\"auc\" , eval_set=eval_set, early_stopping_rounds=10)\n",
    "\n",
    "end_time = time.time()\n",
    "print(f'End Time : {time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(end_time))}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['./model/xgb_model.pkl']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##保存xgb的model\n",
    "joblib.dump(model, './model/xgb_model.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Begin Time : 2020-02-01 21:19:13\n",
      "Transform xgb leaves shape: (859999, 10)\n",
      "Transform xgb x_train_lr shape: (559999, 80)\n",
      "Transform xgb x_test_lr shape: (300000, 80)\n",
      "End Time : 2020-02-01 21:19:15\n"
     ]
    }
   ],
   "source": [
    "#我们来拿到xgb的叶子节点的特征\n",
    "##进行xgboost拟合\n",
    "begin_time = time.time()\n",
    "print(f'Begin Time : {time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(begin_time))}')\n",
    "\n",
    "##apply函数返回的是叶子索引\n",
    "x_train_leaves = model.apply(x_train).astype(np.int32)\n",
    "x_test_leaves = model.apply(x_test).astype(np.int32)\n",
    "\n",
    "#使用nunpy的concatenate来拼接数组，并生成全局的onehot，单一使用train的可能会漏掉编码，test验证的时候出问题\n",
    "x_leaves = np.concatenate((x_train_leaves,x_test_leaves), axis=0)\n",
    "\n",
    "print(f'Transform xgb leaves shape: {x_leaves.shape}')\n",
    "\n",
    "xgb_onehotcoder = OneHotEncoder()\n",
    "xgb_onehotcoder.fit(x_leaves)\n",
    "\n",
    "x_train_lr = xgb_onehotcoder.transform(x_train_leaves).toarray()\n",
    "x_test_lr = xgb_onehotcoder.transform(x_test_leaves).toarray()\n",
    "print(f'Transform xgb x_train_lr shape: {x_train_lr.shape}')\n",
    "print(f'Transform xgb x_test_lr shape: {x_test_lr.shape}')\n",
    "\n",
    "end_time = time.time()\n",
    "print(f'End Time : {time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(end_time))}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ##机器资源较小，进行部分变量内存回收\n",
    "# del df_train,df_vali,df_test,model,x_vali,x_train_leaves,x_test_leaves,x_leaves,xgb_onehotcoder\n",
    "# gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np_train_lr = np.hstack((np.array(np.mat(y_train).transpose()),x_train_lr))\n",
    "# np.savetxt(\"./out_put/encode_data_train_lr.csv\", np_train_lr, delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# del np_train_lr\n",
    "# gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np_test_lr = np.hstack((np.array(np.mat(y_test).transpose()),x_test_lr))\n",
    "# np.savetxt(\"./out_put/encode_data_test_lr.csv\", np_test_lr, delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# del np_test_lr\n",
    "# gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transform xgb x_train_lr2 shape: (559999, 101)\n"
     ]
    }
   ],
   "source": [
    "##进行one特征与原始特征的拼接\n",
    "x_train_lr2 = np.hstack((x_train_lr, x_train.values))\n",
    "print(f'Transform xgb x_train_lr2 shape: {x_train_lr2.shape}')\n",
    "\n",
    "# np_train_lr2 = np.hstack((np.array(np.mat(y_train).transpose()),x_train_lr2))\n",
    "# np.savetxt(\"./out_put/encode_data_train_lr2.csv\", np_train_lr2, delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# del x_train,x_train_lr,x_train_lr2,np_train_lr2\n",
    "# gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transform xgb x_test_lr2 shape: (300000, 101)\n"
     ]
    }
   ],
   "source": [
    "x_test_lr2 = np.hstack((x_test_lr, x_test.values))\n",
    "print(f'Transform xgb x_test_lr2 shape: {x_test_lr2.shape}')\n",
    "\n",
    "# np_test_lr2 = np.hstack((np.array(np.mat(y_test).transpose()),x_test_lr2))\n",
    "# np.savetxt(\"./out_put/encode_data_test_lr2.csv\", np_test_lr2, delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##回收部分资源，资源不够了\n",
    "del df_train,df_vali,df_test,x_vali,x_train_leaves,x_test_leaves,x_leaves,xgb_onehotcoder\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Begin Time : 2020-02-01 21:19:55\n",
      "End Time : 2020-02-01 21:20:19\n"
     ]
    }
   ],
   "source": [
    "###灌入到LR中\n",
    "begin_time = time.time()\n",
    "print(f'Begin Time : {time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(begin_time))}')\n",
    "\n",
    "lr_model = LogisticRegression()\n",
    "lr_model.fit(x_train_lr, y_train)\n",
    "\n",
    "lr_model2 = LogisticRegression()\n",
    "lr_model2.fit(x_train_lr2, y_train)\n",
    "\n",
    "joblib.dump(lr_model, './model/lr_model.pkl')\n",
    "joblib.dump(lr_model2, './model/lr_model2.pkl')\n",
    "\n",
    "end_time = time.time()\n",
    "print(f'End Time : {time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(end_time))}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "##效果输出函数\n",
    "def func_print_score(x_data,y_data,data_type,model_x):\n",
    "    y_pred = model_x.predict(x_data)\n",
    "    \n",
    "    print(f'==============({data_type})===================')\n",
    "    confusion = metrics.confusion_matrix(y_data, y_pred)\n",
    "    print(confusion)\n",
    "    \n",
    "    print('------------------------')\n",
    "    auc = metrics.roc_auc_score(y_data,y_pred)\n",
    "    print(f'AUC: {auc}')\n",
    "    \n",
    "    print('------------------------')\n",
    "    accuracy = metrics.accuracy_score(y_data,y_pred)\n",
    "    print(f'Accuracy: {accuracy}')\n",
    "    \n",
    "    print('------------------------')\n",
    "    aupr = metrics.average_precision_score(y_data, y_pred)\n",
    "    print(f'AUPR: {aupr}')\n",
    "    \n",
    "    print('------------------------')\n",
    "    report = metrics.classification_report(y_data, y_pred)\n",
    "    print(report) \n",
    "    \n",
    "    print('=============================================')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============(testdata-xgb)===================\n",
      "[[248629   3305]\n",
      " [ 44416   3650]]\n",
      "------------------------\n",
      "AUC: 0.5314093688885991\n",
      "------------------------\n",
      "Accuracy: 0.84093\n",
      "------------------------\n",
      "AUPR: 0.18790537837217178\n",
      "------------------------\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.85      0.99      0.91    251934\n",
      "          1       0.52      0.08      0.13     48066\n",
      "\n",
      "avg / total       0.80      0.84      0.79    300000\n",
      "\n",
      "=============================================\n",
      "==============(testdata-xgb-lr)===================\n",
      "[[247447   4487]\n",
      " [ 43073   4993]]\n",
      "------------------------\n",
      "AUC: 0.5430338904724129\n",
      "------------------------\n",
      "Accuracy: 0.8414666666666667\n",
      "------------------------\n",
      "AUPR: 0.19828793875544898\n",
      "------------------------\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.85      0.98      0.91    251934\n",
      "          1       0.53      0.10      0.17     48066\n",
      "\n",
      "avg / total       0.80      0.84      0.79    300000\n",
      "\n",
      "=============================================\n",
      "==============(testdata-xgb-lr2)===================\n",
      "[[251376    558]\n",
      " [ 47867    199]]\n",
      "------------------------\n",
      "AUC: 0.5009626374208841\n",
      "------------------------\n",
      "Accuracy: 0.8385833333333333\n",
      "------------------------\n",
      "AUPR: 0.16064502596303487\n",
      "------------------------\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.84      1.00      0.91    251934\n",
      "          1       0.26      0.00      0.01     48066\n",
      "\n",
      "avg / total       0.75      0.84      0.77    300000\n",
      "\n",
      "=============================================\n"
     ]
    }
   ],
   "source": [
    "func_print_score(x_test,y_test,'testdata-xgb', model)\n",
    "func_print_score(x_test_lr,y_test,'testdata-xgb-lr', lr_model)\n",
    "func_print_score(x_test_lr2,y_test,'testdata-xgb-lr2', lr_model2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7392"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del x_train,y_train,x_train_lr,x_train_lr2\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "##测试数据的PR曲线\n",
    "probas_xgb = model.predict_proba(x_test)\n",
    "probas_lr = lr_model.predict_proba(x_test_lr)\n",
    "probas_lr2 = lr_model2.predict_proba(x_test_lr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "##precision_recall_curve函数\n",
    "precision_xgb,recall_xgb, thresholds_xgb = metrics.precision_recall_curve(y_test, probas_xgb[:,1])\n",
    "precision_lr,recall_lr, thresholds_lr = metrics.precision_recall_curve(y_test, probas_lr[:,1])\n",
    "precision_lr2,recall_lr2, thresholds_lr2 = metrics.precision_recall_curve(y_test, probas_lr2[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'PR Curve')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAGDCAYAAAAYtQWTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAIABJREFUeJzs3Xd0VNX6xvHvTgESaqgCgtRQA6FXQfGKqAhSRMHyU1GqIFiwXgtXsYCCoqCi2K4CItKEq2CjKwkQQpEmRUClCKGGJCT798dJMEASBpLJmWSez1qzMnNmcs4bF5DHvfd5t7HWIiIiIiI5K8DtAkRERETyI4UsERERES9QyBIRERHxAoUsERERES9QyBIRERHxAoUsERERES9QyBIRERHxAoUskTzOGLPTGBNvjDlujNlnjPnIGFMk9b2fjDGnUt87aIz5yhhT/gLna26MmW+MiTPGHDLGrDTG3JM7P42ISP6hkCWSP9xkrS0CNAaaAk+ne++B1PdqAEWAMZmdxBjTCvgBWJT6+VLAQOD6SynKGBN4Kd8nIpIfKGSJ5CPW2r3A/4D6GbwXB8wCIrM4xWjgY2vtK9bag9axylrbC8AYc7cxZmn6bzDGWGNMjdTnHxljJqaOhJ0AHjHG/JU+bBljuhljYlOfBxhjHjfG/GaM+dsY84UxpmQ2/zOIiPgEhSyRfMQYUwm4AViTwXulgO7Atky+NxRoBXyZzTL6AC8CRYE3gBNAh3Pe/zz1+RDgZqA9UAE4DLydzeuLiPgEhSyR/GGWMSYOWIoz1Tcq3XtvGmOOAAeB0jjBJiNhOP8m/JnNWmZba5dZa1OstaeAKUBvAGNMUZwQOCX1swOAp6y1e6y1CcBzQE9jTFA2axARcZ1Clkj+cLO1toS19gpr7SBrbXy694Zaa4sDDXCC1OWZnOMwkAJkuTDeA7vPef050N0YUxBnJG21tXZX6ntXADNTF9nHAb8CyUC5bNYgIuI6hSwRP2GtXQe8ALxtjDEZvH8SWAH0yOI0J4DQtBfGmMsyutQ5590I7MJZPJ9+qhCcQHZ9akBMexRKXVsmIpKnKWSJ+JePcUaJumTy/gjgbmPMo6lruDDGNDTGTE19fy1QzxgTaYwphDO954nPgQeBdsD0dMffAV40xlyReq0yxpiuF/MDiYj4KoUsET9irU3EWYz+70zeX46zSL0DsN0Ycwh4D5if+v4WYCTwHbAVZw2YJ6bgLG7/wVp7MN3xN4A5wAJjzDHgZ6DFRf5YIiI+yVhrL/wpEREREbkoGskSERER8QKFLBEREREvUMgSERER8QKFLBEREREvUMgSERER8YI8t3VF6dKlbZUqVdwuQ0REJFesWrXqoLW2jNt1yMXLcyGrSpUqREdHu12GiIhIrjDG7Lrwp8QXabpQRERExAsUskRERES8QCFLRERExAsUskRERES8QCFLRERExAsUskRERES8QCFLRERExAsUskRERES8QCFLRERExAu8FrKMMZONMfuNMeszed8YY940xmwzxsQaYxp7qxYRERGR3ObNkayPgE5ZvH89UDP10Q+Y6MVaRERERHKV10KWtXYxcCiLj3QFPrGOn4ESxpjy3qonIxvWbuGT174kKdHm5mVFRCSfSkxMdLsE8SFursmqCOxO93pP6rHzGGP6GWOijTHRBw4cyLEC3vziPQZue46tqzbm2DlFRMQ/LVmyhPDwcJYvX+52KeIj8sTCd2vte9baptbapmXKlMmx85aq5GS6/Wu25Ng5RUTEP1lrCQ0NJTQ01O1SxEe4GbL2ApXSvb489ViuuaxKNQCObNyTm5cVEZF84vfff+f9998HoF27dqxbt47IyEiXqxJf4WbImgPclXqXYUvgiLX2z9wsoEjRAAgI4Ohv+3PzsiIikg/MnDmTyMhIHn74YdKWsgQGBrpclfgSb7ZwmAKsAGoZY/YYY/oaYwYYYwakfmQ+sB3YBkwCBnmrlswUKQKYAI7sPg4JCbl9eRERyYPi4+MZNGgQ3bt3p1q1aqxatYqcXMoi+UeQt05sre19gfctMNhb1/dEoYJgAg1HTheGTZugYUM3yxERER+XnJxM+/btiYqK4uGHH2bUqFEUKFDA7bLER+WJhe/eYgwEBgcQl1wY1q1zuxwREfFRzriAMx04cOBA5s+fz5gxYxSwJEt+HbIAgoINRwqWU8gSEZEMxcXFceuttzJt2jQA7rnnHq6//nqXq5K8wO9DVmAgHC1cQSFLRETO8/PPP9OoUSO++uor9u3b53Y5kscoZAVCXHBp2L/feYiIiN9LSUnh5Zdfpm3btgAsXbqUoUOHulyV5DUKWUFwhBLOi/UZ7mUtIiJ+5vvvv+eJJ56gR48erFmzhpYtW7pdkuRBfh+yggLhREohkoJCNGUoIuLn9u51emJfe+21/PTTT0ydOpUSJUq4XJXkVX4fsgIDARNAXLXGClkiIn4qMTGRRx55hBo1arA+dVajffv2GGNcrkzyMr8PWUGpncIOX9EQNm6E06fdLUhERHLVtm3baNOmDa+99hr33nsv1atXd7skySf8PmSl7YAQV6EeJCbC1q3uFiQiIrnms88+o1GjRvz222989dVXvP3224SEhLhdluQTfh2yjDEEpo5kxZWp6TzRlKGIiN9Yu3YtkZGRxMTE0K1bN7fLkXzGa9vq5BVBgZAMHCYMSpd27jDs1cvtskRExEvWrFlDQkICLVu25MUXX8QYQ1CQ3/86FC/w65EscKYLAwLgcJyBiAiNZImI5FPWWt544w1atmzJ8OHDsdYSHBysgCVe4/chC6BYMTh8GCdk7d4NcXFulyQiIjno4MGDdOnShWHDhnHdddcxd+5c3TkoXqeQRbqQVb++c0BNSUVE8o2dO3fSsGFDFixYwBtvvMHs2bMpXbq022WJH1DIAooXTx28qlPHmTvUlKGISL5RuXJlunTpws8//8zQoUM1giW5RiELJ2QdPgyEhEDNmgpZIiJ53O+//06XLl3Ys2cPAQEBTJw4kUaNGrldlvgZhSzShSxw1mWtXw8pKa7WJCIil+arr76iYcOG/Pjjj2zcuNHtcsSPKWThhKwjR1JzVUQEnDwJO3e6XZaIiFyE+Ph4Bg0aRI8ePahRowYxMTF07NjR7bLEjylk4YQsa52gRUSEc1BThiIiecrzzz/PxIkTeeSRR1i2bJm2xxHXKWQBaRusx8UBlSo5txsqZImI+DxrLXGpbXeeeOIJFixYwOjRoylQoIDLlYkoZAFOpoLUdVnGOK0cFLJERHxaXFwct956K1dddRWnTp2iePHiXHvttW6XJXKGQhbOdCGk60EaEQHbt8OJE67VJCIimVuxYgWRkZHMnDmT3r17a+RKfJJCFlC8uAXOucPQWtiwwb2iRETkPMnJyYwaNYorr7wSYwxLly7lscceIyBAv87E9/j1n0qD05DurOlCgHr1nK/q/C4i4lOSkpKYNm0aPXv2JCYmhhYtWrhdkkimtCsmEBQERYqkC1lFi0LVqlqXJSLiIxYuXEiLFi0oVqwYixYtonjx4urcLj7Pr0ey0gsLSxeywJkyXLfOmTYUERFXJCYm8vDDD9OxY0defvllAEqUKKGAJXmCQlaqsLB0C9/BucMwLg727nWtJhERf7Zt2zZat27N66+/zuDBg3nmmWfcLknkomi6MFWJEvDnn+kOpG9KevnlrtQkIuKvvv32W3r27ElwcDBfffUV3bp1c7skkYumkaxU500XVq/ubBitdVkiIrmubt26dOjQgZiYGAUsybMUslKlTReeWYIVEODcZag7DEVEcsXq1asZNGgQKSkpVKpUidmzZ1O5cmW3yxK5ZApZqcLC4PRpOH483cGICNi8GRISXKtLRCS/s9Yybtw4WrZsyezZs9m9e7fbJYnkCIWsVGFhztezFr9HREByMmza5EpNIiL53YEDB7jpppsYPnw4nTp1Yu3atVxxxRVulyWSIxSyUqVtEn3Wuqz69Z2vWpclIpLjrLV07tyZhQsX8uabbzJ79mxKly7tdlkiOUZ3F6bKcCSrZEmoUEEhS0QkB50+fRprLcHBwYwdO5bQ0FAiIyPdLkskx2kkK1VayDprJAv+aUoqIiLZtmvXLtq3b3+m51Xr1q0VsCTfUshKleF0ITgha/9+5yEiIpdsxowZREZGsm7dOho0aOB2OSJep5AFWCyFCkGhQpmELFArBxGRSxQfH8+AAQPo2bMnNWvWZM2aNfTu3dvtskS8zq9D1rl7X53XkBQgPBwKFNCUoYjIJfrtt9/4+OOPGTFiBEuXLqV69epulySSK7TwPZ3z9i8ECA6G2rUVskRELoK1lsWLF9O+fXvq16/Ptm3bqFixottlieQqvx7JOleJEhmMZIHTymHjRqdbqYiIZCkuLo5evXpx1VVX8f333wMoYIlfUshKJ8PpQnDWZSUmwtatuV6TiEhesnz5ciIjI5k1axavvPIKV199tdslibhGISudLEMWaMpQRCQL48aNo127dgQEBLB06VJGjBhBQIB+zYj/0p/+dMLCnG0K4+PPeaNcOShdWncYiohkoVy5ctxyyy2sWbOGFi1auF2OiOsUstLJsOs7gDFqSioikoH58+fz0UcfAdC7d28+//xzihcv7m5RIj5CISudTBuSghOydu/OIIGJiPifhIQEHnroIW688UYmTpxIcnIycH5rHBF/ppCVTqYjWfDPZtGaMhQRP7d161Zat27N2LFjGTx4MIsWLSIwMNDtskR8jvpkpZPlSFadOhAQ4EwZtm2bq3WJiPiK/fv306RJE4KCgpg5cyY333yz2yWJ+CyFrHQy3SQaICQEatbUuiwR8UvJyckEBgZStmxZxowZw/XXX0+lSpXcLkvEp2m6MJ3ChSEoKJOQBc66rPXrISUlV+sSEXHT6tWrqV+/PkuXLgWgX79+ClgiHlDIwtn+AZybCDPtlQVOyDp5EnbuzLXaRETcYq1l3LhxtGzZkuPHj2tRu8hF8mrIMsZ0MsZsNsZsM8Y8nsH7lY0xPxpj1hhjYo0xN3izHk9kuH9hGjUlFRE/ceDAATp37szw4cO54YYbiImJoU2bNm6XJZKneC1kGWMCgbeB64G6QG9jTN1zPvY08IW1thFwGzDBW/V4KtP9CwEqVYJixRSyRCTf+/zzz/n+++956623mDlzJqVKlXK7JJE8x5sjWc2Bbdba7dbaRGAq0PWcz1igWOrz4sAfXqzHI1lOFxrjtHJQyBKRfOj06dNs3LgRgCFDhhAbG8vgwYM1TShyibwZsioCu9O93pN6LL3ngDuMMXuA+cAQL9bjkSxDFjhThtu3w4kTuVaTiIi37dq1i/bt29OuXTsOHz5MQEAA4eHhbpclkqe5vfC9N/CRtfZy4AbgU2PMeTUZY/oZY6KNMdEHDhzwakFhYU5+SkzM5AMREWAtbNjg1TpERHLLjBkziIyMZN26dYwfP56wtH42IpIt3gxZe4H09/hennosvb7AFwDW2hVAIaD0uSey1r5nrW1qrW1apkwZL5XrSPu35ciRTD5Qr57zVZ3fRSSPO336NAMGDKBnz56Eh4cTExND79693S5LJN/wZsiKAmoaY6oaYwrgLGyfc85nfgeuATDG1MEJWd4dqrqALLu+AxQtClWral2WiOR5gYGBHDlyhBEjRrBkyRKqVavmdkki+YrXOr5ba08bYx4AvgUCgcnW2g3GmJFAtLV2DvAwMMkYMxxnEfzdNq1plUvSQlaW+0BHRMDixc60oRaEikgeYq1l0qRJtG/fnlq1avHZZ58REOD2yhGR/Mmrf7OstfOtteHW2urW2hdTjz2TGrCw1m601rax1ja01kZaaxd4sx5PZLm1Tpr69Z0Utvfc2U8REd91+PBhbrnlFvr378+ECU7HHAUsEe/R365zeBSy1JRURPKY5cuXExkZyezZs3nllVcYO3as2yWJ5HsKWecoVgwCAi4QsqpXdzaMVsgSkTzg22+/pV27dgQGBrJ06VJGjBihESyRXKC/ZecICIDixS8QsgICnLsMdYehiPiwtCWu7du359FHH2XNmjW0aNHC5apE/IdCVgay3L8wTUQEbN4MCQm5UpOIyMWYN28erVu35ujRoxQqVIiXXnqJ4sWLu12WiF9RyAIsZ9/QmOX+hWkiIiA5GTZt8l5hIiIXKSEhgeHDh9O5c2dOnjzJoUOH3C5JxG/5dcgyZNx+4YJb64BzhyFoXZaI+IwtW7bQunVrxo0bx5AhQ/jll1+oUqWK22WJ+C2v9cnKyzwKWSVLQoUKClki4jOGDRvGzp07mT17Nl26dHG7HBG/p5CVgbAwOHoUUlKcNe6ZioiANWtyrS4RkXMdO3aMxMRESpUqxXvvvQfA5Zdf7nJVIgJ+Pl2YmbAwp5l7pvsXpomIgP37nYeISC5btWoVjRs35v/+7/8AJ1wpYIn4DoWsDFxw/8I0aU1J1cpBRHKRtZaxY8fSqlUrTp06xYgRI9wuSUQyoJCVAY/2LwQID4cCBbQuS0RyzcGDB+ncuTMPPfQQN9xwAzExMbRr187tskQkAwpZGfBoax2A4GCoXVshS0Ry1ebNm3nrrbeYOXMmpUqVcrscEcmEQlYGPA5Z4LRy2LgRTp/2ak0i4r+SkpJ4++23SUpKonTp0mzcuJHBgwdjTMZtaETENyhkZcDjNVngrMtKTIStW71ak4j4p507d9KuXTseeOAB5syZA0CBAgVcrkpEPKGQlYGgICha9CJCFmjKUERy3PTp04mMjGTDhg1MmTKFHj16uF2SiFwEhaxMeLR/IUC5clC6tO4wFJEc9cILL9CrVy9q1apFTEwMt912m9slichFUjPSTHi0fyGAMc5olkayRCQHde7cmRMnTjBy5EiCg4PdLkdELoFGsjLh0dY6aSIiYPduD4e+RETOZ63lnXfeYejQoQBERkby0ksvKWCJ5GEKWZm4qJCVtlm0pgxF5BIcPnyYW265hYEDB7JlyxYSEhLcLklEcoBfh6ysbn9OW5NlrQcnqlPH2eRQU4YicpGWLVtGZGQks2fPZvTo0cyfP5+CBQu6XZaI5ACtycpEWBgkJ8Px486dhlkKCYGaNRWyROSiHDt2jJtuuomwsDCWL19Os2bN3C5JRHKQX49kZeWiemWBsy5r/XpISfFaTSKSPxw8eBBrLUWLFmXOnDmsWbNGAUskH1LIyoTH+xemiYiAkydh505vlSQi+cC8efOoU6cO7777LgBt27alWLFiLlclIt6gkJWJi9paB9SUVESylJCQwPDhw+ncuTMVK1bkqquucrskEfEyhaxMXHTIqlQJihVTyBKR82zZsoVWrVoxbtw4hgwZws8//0zt2rXdLktEvEwL3zNx0SHLGKeVg0KWiJxj+/bt7N69m9mzZ9OlSxe3yxGRXKKRrEwULOjcNOhxyAInZG3fDidOeK0uEckbjh07xuzZswHo1KkT27dvV8AS8TMKWVnweP/CNBERTmOtDRu8VpOI+L7o6GgaNWpEr1692Lt3LwBFL9gLRkTyG4WsLHi8f2GaevWcr+r8LuKXUlJSeP3112ndujUJCQl89913VKxY0e2yRMQlWpOVhbAw+Pvvi/iGYsWgShWtyxLxQ9ZaunXrxpw5c7j55pv54IMPKFmypNtliYiLFLKyEBYG27Zd5DdFRMCSJc60YRbb9ohI/mKMoX379nTs2JFBgwZluW2XiPgHTRdm4aLXZIETsuLiIHUdhojkX0lJSTz55JN8/fXXADz00EMMHjxYAUtEAIUswBnmz0iJEpCQAPHxF3Gy+vWdr5oyFMnXdu7cSbt27XjppZdYvHix2+WIiA/y65BlyPr/Ni+6VxZA9epO7weFLJF8a/r06URGRrJx40amTp3Kq6++6nZJIuKD/DpkXchF718IEBgIdevqDkORfGrJkiX06tWL2rVrExMTw6233up2SSLioxSysnBJI1ngrMvavNmZaxSRfOFEapPhtm3b8tlnn7FkyRKqVq3qclUi4ssUsrKQrZCVnAybNuV4TSKSu6y1vPPOO1SpUoUtW7ZgjKFPnz4EBwe7XZqI+DiFrCxccsjS4neRfOHw4cP07NmTgQMH0qRJE4oXL+52SSKShyhkZSE0FIKDLyFklSoFFSooZInkYcuWLSMyMpI5c+YwZswY5s+fT7ly5dwuS0TyEDUjzYIxl9grC5zRrJiYHK9JRHLHlClTCA4OZvny5TRr1sztckQkD9JI1gVc9P6FaSIiYP9+5yEiecLevXtZlzoCPXr0aFavXq2AJSKXTCHrAsLCshGyQK0cRPKIr7/+moYNG3LnnXdirSUkJIRixYq5XZaI5GEKWRdwySErPNxZ0KV1WSI+LSEhgWHDhnHTTTdRqVIlpk2bpm1xRCRHaE3WBZQocYlrsgoUgNq1FbJEfNi+ffu4/vrrWbNmDUOHDuWVV16hUKFCbpclIvmERrIuICwMTpyAxMRL+OaICNi4EU6fzvG6RCT7SpUqReXKlZk9ezZvvPGGApaI5CiFrAtI65V1yXcYJibC1q05WpOIXLqjR48yZMgQ9u/fT1BQELNmzaJLly5ulyUi+ZBCFmCxmb53SfsXpklb/K4pQxGfEB0dTePGjZkwYQI//vij2+WISD7n1yHLk8Wtl9z1HeCyy5zGpLrDUMRVKSkpvPbaa7Ru3ZrExEQWLVqkjZ1FxOv8OmR5IlshyxhnNEsjWSKuGjVqFI888gidO3cmJiaGtm3bul2SiPgB3V14AdkKWeCErJ9+cuYb0+YeRSRXJCUlERwczIABAyhfvjz33nuv2jOISK654EiWMSbUGPNvY8yk1Nc1jTGdvV+abyhaFAICshmyQFOGIrkoKSmJJ554gquuuoqkpCRKly5N3759FbBEJFd5Ml34IZAAtEp9vRd4wZOTG2M6GWM2G2O2GWMez+QzvYwxG40xG4wxn3tUdS4KCMhGryyAOnWck2jKUCRX7Ny5k3bt2vHyyy9Tt25dTquFioi4xJPpwurW2luNMb0BrLUnjQf/O2iMCQTeBq4F9gBRxpg51tqN6T5TE3gCaGOtPWyMKXtJP4WXXfL+hQAhIVCjhkKWSC6YPn06999/P9Zapk6dqsXtIuIqT0ayEo0xIeD0OTDGVMcZ2bqQ5sA2a+12a20iMBXoes5n7gfettYeBrDW+uRuype8tU6aiAhnujAlJcdqEpGzJSQk8PTTT1OnTh1iYmIUsETEdZ6ErOeAb4BKxpjPgO+Bxzz4vorA7nSv96QeSy8cCDfGLDPG/GyM6ZTRiYwx/Ywx0caY6AMHDnhw6ZyVrZEscELWyZOwc2dOlSQiqTZs2MDJkycpWLAgCxcuZPHixVStWtXtskRELhyyrLULgO7A3cAUoKm1Nqe6+AUBNYGrgN7AJGPMebfgWWvfs9Y2tdY2LVOmTA5d2nNhYdlYkwVqSiriBdZaJk6cSNOmTXn22WcBqFy5MsHBwS5XJiLi8OTuwu+ttX9ba+dZa7+21h40xnzvwbn3ApXSvb489Vh6e4A51toka+0OYAtO6PIpYWFw9Gg2ZvsqVYJixRSyRHLIoUOH6NGjB4MGDeKqq67i0UcfdbskEZHzZBqyjDGFjDElgdLGmDBjTMnURxXOn/bLSBRQ0xhT1RhTALgNmHPOZ2bhjGJhjCmNM324/aJ/Ci8LCwNrszGaFRDg7GOokCWSbVFRUURGRvL1118zZswY5s2bR9myPnnPjIj4uazuLuwPDAMqAKuAtDsKjwJvXejE1trTxpgHgG+BQGCytXaDMWYkEG2tnZP6XkdjzEYgGXjUWvv3Jf80XpJ+/8KSJS/xJPXrw4oVcOIEFC6cY7WJ+JuwsDBKly7NV199RdOmTd0uR0QkU5mGLGvtG8Abxpgh1trxl3Jya+18YP45x55J99wCD6U+fFa2u76Dsy7LWtiwAZo3z5G6RPzFnj17+PDDD3n66aepUaMGq1atUmNREfF5F+yTZa0db4ypD9QFCqU7/ok3C8tNTtbLXI6ErHr1nK/r1ytkiVyEOXPmcM8995CQkMCtt95KeHi4ApaI5AmeLHx/Fhif+rgaeBXo4uW6fEqOhKxixaBKFa3LEvHQqVOnGDp0KF27duWKK65g1apVhIeHu12WiIjHPOmT1RO4BvjLWnsP0BAo7tWqfEzx1J82WyELnCnDdeucaUMRydLNN9/M+PHjefDBB1mxYgW1atVyuyQRkYviSciKt9amAKeNMcWA/ZzdmiHfCwpyBqKy1SsLnJAVFwd7z+1kISLgTN2nTd8//PDDzJ07l3HjxlGwYEGXKxMRuXie7F0YndogdBLOXYbHgRVercoHZbvrOzh3GIIzmnX55dmuSSQ/OXr0KAMHDqRu3bo89dRTXHvttW6XJCKSLZ50fB9krY2z1r6Ds9nz/6VOG/qVHAlZ1as7G0ZrXZbIWaKiomjcuDFTp07VonYRyTc8mS48w1q7EzhljJnknXJ8V7a31gEIDIS6dZ07DEWElJQUxowZQ+vWrUlMTGTRokU8+eSTbpclIpIjsur43sAYs8AYs94Y84IxprwxZgbwA7Ax90r0DWFhOTCSBc66rM2bISEhB04mkrdt3LiRxx9/nJtuuomYmBjatm3rdkkiIjkmq5GsScDnQA/gABAD/AbUsNaOzYXafEraSFa2bwyMiIDkZNi0KUfqEsmLtm7dCkD9+vWJiopixowZlLzk7RRERHxTViGroLX2I2vt5tTu7yestSOstadyqzhfEhbmZKNjx7J5ovSL30X8TFJSEk888QS1a9dm4cKFADRq1EjrsEQkX8rq7sJCxphG/LNnYUL619ba1d4uzpek37+wWLFsnKhUKahQQSFL/M6OHTvo06cPP//8M/fffz9t2rRxuyQREa/KKmT9Cbye7vVf6V5boIO3ivJF6bu+V66czZPVrw8xMdmuSSSvmDFjBvfeey/GGL744gtuueUWt0sSEfG6rDaIvjo3C/F1ObK1TpqICFiwAPbvh7Jlc+CEIr7t0KFD1K1blylTplClShW3yxERyRWeNCPN9ywXXs2eFrIWLoRDh6BwYQgNdb6GhPzzOjTUeZ3lEpOICOfr+vXQwa8GBMWPxMbGsmPHDrp27cp9993HPfeZaonIAAAgAElEQVTcQ1CQ/skREf/h1//iGTxfbFuypDPo9O23ziPL8xonaKWFrvQBLDQUCheqTejBOwh91xL6x9mfySy0WQsff+ysB+vSBYKDs/nDi3iJtZYJEybw8MMPU7lyZW688UaCgoIUsETE7+hfPQ8FB8PXX8PJk2c/TpyA+Hjna9rrjD5z8qQzO+i8DuJk/A2cWhgIK/+GlJQMHslnv7ZAieJQqhQffRTEfffBjTc6+yqK+IpDhw7Rt29fZs2axfXXX89HH32kcCUifsujf/2MMRWBK9J/3lq72FtF+aqAAChSxHlk28TvSXl/MvEpBTmREsLJAiX+eQQV40RQcU4GFOFEQFH+Sghj7sbq3BP4LnXsn0zcP4z/PFeDDz8MpF8/6NTJqU3ETYcPHyYyMpK//vqL1157jWHDhhGgP5gi4scuGLKMMa8At+J0eU9OPWwBvwtZOWrAAAJ69aJwSAiFCxW6YEoaAbDjTnjvPVouuJ0lKa14548HeebpqkyeHEj//nDNNQpb4p6wsDD69+9Pp06daNKkidvliIi4zpNfyTcDtay1N1hrb0p9dPF2YfmeMU7PrNBQz5NR1arw0kuYaVNp17EQ/03uzat2BAG7dvDEY8ncfjv89FMOdKUX8dCePXvo2LEjq1atAuCpp55SwBIRSeXJb/ftgJZZ+5IaNWD0aAI++5QOV6UwNaUXL9inSdi6i0ceTuGuu2DZMoUt8a45c+bQsGFDli9fzq5du9wuR0TE53gSsk4CMcaYd40xb6Y9vF2YeKB2bRg7loBPPqJT2+NMt7fwbMpzHNm4hweHptC3L6xcqbAlOevUqVMMHTqUrl27csUVV7B69Wq6d+/udlkiIj7Hk5A1B/gPsBxYle4hvqJePRg/nsDJk7ip5QG+ogdPprzIX2v+ZNDAFPr3hzVr3C5S8ov333+f8ePH8+CDD7JixQrCw8PdLklExCddcOG7tfZjY0wBIO1f0s3W2iTvliWXpGFDmDiRoFWr6D5xIp1Xd2Nmys1MXnkP968qS4uWhoED/9mjWsRT1lr27dvHZZddxoABA4iIiKB9+/ZulyUi4tMuOJJljLkK2Aq8DUwAthhj2nm5LsmOJk1g0iQKTHyDWxtuYnZAN4bZsWxeeoC777YMHw6bV5/QPKJ45OjRo9xxxx00btyYv//+m6CgIAUsEREPeDJd+BrQ0Vrb3lrbDrgOGOvdsiTbjIEWLeDDDyk0fjR31FvDnMCbGZzyFms/W8ftV+6i37U7lLMkS1FRUTRu3Jhp06YxePBgSpQo4XZJIiJ5hichK9hauznthbV2C7rbMO8wBtq0gU8+IXTsKO4JX8acioNoV2QNq39OYPviPW5XKD4oJSWFMWPG0Lp1a5KSkli0aBFPPfUUgYGBbpcmIpJneBKyoo0x7xtjrkp9TAKivV2Y5DBjoH17+Pxzisz/gke+60SBwBQmDY6B5OQLf7/4FWMMixYtokuXLsTExNCmTRu3SxIRyXM8CVkDcbq9D019bEw9JnlRQACUL0+FiFLcd5/lux3VWPzvhW5XJT5i4cKF7Ny5E2MM06ZN48svvyQsLMztskRE8qQLhixrbYK19nVrbffUx1hrbUJuFOdtxhi3S3DVnS/Vo0blRF5+uygnFmlw0p8lJSXx2GOP0bFjR5577jkAQkND/f7viIhIdmQasowxX6R+XWeMiT33kXslircEFzD8+4OqHEgpyRu3r4Tjx90uSVywfft22rZty6uvvkr//v2ZMGGC2yWJiOQLWfXJejD1a+fcKETcUa91ce68/zCfvHs14XfNoeeM3s76LfELK1asoFOnThhjmD59Oj179nS7JBGRfCPTkSxr7Z+pTw8Cu621u4CCQEPgj1yoTXLJ4NFVaNs6hZe/jeTD4WvV1sGPREREnFncroAlIpKzPFn4vhgoZIypCCwA7gQ+8mZRkrsCA+HVuXXoVGsnb39QiFEPHdQNh/lYbGwsPXv25OTJkxQpUoRPP/2UKlWquF2WiEi+40nIMtbak0B3YIK19hagnnfLktxWoFAAI+c35d7LFzLzg0MMH5TAyZNuVyU5yVrL22+/TfPmzVm2bBnbt293uyQRkXzNo5BljGkF3A7MSz2mjoT5UMBlZRk0qyNPlZ/Mz7P3cd99lv373a5KcsKhQ4fo1q0bDzzwANdccw2xsbHU1yaWIiJe5UnIGgY8Acy01m4wxlQDfvRuWeKaWrXo9mwDxpV4jj1rDnL33bBtm9tFSXbde++9zJ8/n9dff525c+dSpkwZt0sSEcn3POmTtcha28Va+0rq6+3W2qHeL01c07s3ra8ryvuFHsAeP0HfvrBypdtFycVKTk7meGpbjjFjxrBixQqGDx9OQIAn/28lIiLZlVWfrHGpX+caY+ac+8i9EiXXGQPPPkt42Tg+Kv4g5csmM2QIzJ3rdmHiqT179nDNNddw9913Y62lRo0aNGnSxO2yRET8SlZ9sj5N/TomNwoRH1OyJIwcSbnBg3n/xtcZUeZRnn8e/vgD+vVTKy1fNmfOHO655x4SEhKYMGGCuraLiLgk05BlrV2V+jQaiLfWpgAYYwJx+mVJfteiBdx1F0U++YQ3X2rKi+WuZtIkJ2g9/TQEB7tdoKR36tQpRowYwfjx42nUqBFTp04lPDzc7bJERPyWJ4szvgdC070OAb7zTjnicwYOhLp1CRo1kmf6/cWAATBvHgwdCseOuV2cpBcXF8e0adMYNmwYK1asUMASEXGZJyGrkLX2zKZ2qc9Ds/h8nmPV4jxzwcEwahQkJ2Oe+Tf33ZPMyJGwZg307Qt//nnhU4j3WGuZO3cuycnJXHbZZfz666+MHTuWggU12Cwi4jZPQtYJY0zjtBfGmCZAvPdKyj0GrVXxyOWXw+OPO8nqgw+44QYYPx7274c774ToaLcL9E9HjhyhT58+dOnShc8++wyAkiVLulyViIik8bRP1nRjzBJjzFJgGvCAd8sSn3PDDc7j/fchJoZmzWDyZChWzJlRfPNNSEpyu0j/sXLlSho1asT06dN58cUXuf32290uSUREzuFJn6wooDYwEBgA1Em3KF78yeOPQ4UK8NRTcPQo1arBZ59Bt27wySdw992wY4fbReZ/77//Pm3atCE5OZnFixfz5JNPEhioTRhERHzNBUOWMSYUeAx40Fq7HqhijOns9crE94SGOuuzDh6EF14AawkJgSefhNdeg3374PbbYfp00DI376lXrx49evQgJiaG1q1bu12OiIhkwpPpwg+BRKBV6uu9wAteq0h8W926MHgw/PADzJp15nD79jBtGjRpAq+8AsOHw6FDLtaZzyxYsIAXXnD+2rVq1YqpU6cSFhbmclUiIpIVT0JWdWvtq0ASgLX2JGjFuF+74w6nh9aYMRAVdeZwqVLwxhvwyCPONjy33QZLl7pYZz6QmJjIiBEjuO6665g2bRonT550uyQREfGQJyEr0RgTAlgAY0x1IMGrVYlvCwiAkSPhsstg0CB49lnnVsPUt267DT791Aldw4bB889rVOtSbN++nSuvvJLRo0fTv39/fvnlF0JD81X3FBGRfM2TkPUs8A1QyRjzGU5z0hFerSqfOppwNP/05CpVCv77X6eHw8KF0L07fPABJDj5u3p1+PhjZzH83Llw000wYQIcOeJu2XlFfHw8bdq0YfPmzUyfPp133nlHAUtEJI/JMmQZZ9OzTUB34G5gCtDUWvuTJyc3xnQyxmw2xmwzxjyexed6GGOsMaapx5XnIa8sfYWm7zWlw8cdaDapGU9+/+R5n5mxcQZN32tK16ldXajwEoWEOK3fv/wSWreGiROhZ0/4/nuwlgIF4IEH4IsvoF07+PBDJ2wtW+Z24b4rITWkhoSE8O677xITE0PPnj1drkpERC5FliHLOsMu8621f1tr51lrv7bWHvTkxKl7HL4NXA/UBXobY+pm8LmiwIPALxddvY9LsSk0fa8p0zdOP+v4gt8WEHcq7szr6Rum89LSlwDYe3RvrtaYIypUgFdfhXfegSJF4LHHoH9/2LIFgGrV4KWXnIXxJUrAo486LR+OHnW5bh+zdu1aIiMj+fRTZ2/2Ll26UKVKFXeLEhGRS+bJdOFqY0yzSzh3c2CbtXa7tTYRmApkNEzzH+AV4NQlXMNnpdgUmk9qfuZ1uSLlGHXNqDOvfz3wKwAbD2zklWWvnPW9sftic6fInNa0qdM468kn4bffnH4Oo0bB4cOAE7ZGj4aICKd56Y03Otns999drttl1lreeustWrRowZEjR6hYsaLbJYmISA7wJGS1AH42xvxmjIk1xqwzxniSAioCu9O93pN67IzU7XoqWWvnZXUiY0w/Y0y0MSb6wIEDHlzaXa8ue/WsgDWvzzzm9ZlHx+od+brP1wDsP7GfP479wV0z7wLgqSuf4u0b3gbg3tn35n7ROSUgwFmfNXMm9O4Ns2fDddfBv/8NP/1ErSoJvPsufP45XHON87EePZyWDytX+l9/rUOHDtGtWzeGDBnCNddcw9q1a+nQoYPbZYmISA4I8uAz13njwsaYAOB1nLVeWbLWvge8B9C0aVOf+DW89+he/jz+JwO+HnDm2PK+y2n9wdnNIaPuj8JZ2uYIDXYWL/9n8X/OHOtSqwvd6nTzcsW5rFgxeOghJ3C9/76zEOt//3PWcbVpQ/g11/DciDYMGRLKl186y7oGDYIqVeDWW50u8kGe/OnM45YsWcL8+fN5/fXXGTZs2Fl/VkREJG/L9NeYMaYQzjY6NYB1wAfW2tMXce69QKV0ry9PPZamKFAf+Cn1F8tlwBxjTBdrba5uOWzxPLet3LuSQfMGZfjehQIWQOHgwud93zPtnznzPCwkjMPxhzkUf4iSIflgs98qVZzu8KdPw6pVzqL4n36C776DAgUo1bo1/Tt04J5p7Vi4oghffOE0M/3iC6ffVosWbv8AOe/06dNERUXRqlUrunbtyrZt26hcubLbZYmISA7LarrwY6ApTsC6HnjtIs8dBdQ0xlQ1xhQAbgPmpL1prT1irS1tra1ira0C/AzkasC62FGDCVETMgxYY68be9br4S2HE90vOsPzBwYE0rF6RwAebf0o0f3O/nFvqXsLAJsObrqo2nxeUJCTmJ58Er75Bt57zxmu2rABnnmGAjf8ixsXPMhH3efw+sjjJCU5jeUfeQT25sF7ATKze/duOnToQPv27dmRutGjApaISP6UVciqa629w1r7LtATuPJiTpw66vUA8C3wK/CFtXaDMWakMabLJVfskvikeCavmXzm9Xs3vQfAgjsXcOUVV1K+aHkAovtFc3uD27M816hrRhHdL5pb69963nvNKzprubYf3p5TpfuegABo3Ni5zXDePJg82elgun075j8jafdcB74o/yAP9P6bX36BW25xemzFx7tdePbMnj2byMhI1qxZw+TJk6latarbJYmIiBdlteolKe2Jtfb0pawVsdbOB+afc+yZTD571UVfIBfN3DTzzPO00af0o1Bze8/NkeuUL+KEta1/b82R8/m8gABo0MB5PPggbNoECxdS4JNPuDvqOm6s2ZrxR+5k8vi6fD0nhAeHB9CxI+SlpUvWWoYNG8abb75JkyZNmDJlCjVr1nS7LBER8bKsRrIaGmOOpj6OAQ3Snhtj/K7D0esrXgecxe3eVK5IOQA2Htzo1ev4JGOgTh2nwennn0PfvpQJOc7Ig4OZbPpSatUCnrpzF/e338zmOZshOdntij1ijKF48eI89NBDLF++XAFLRMRPZDqSZa0NzM1CfNmPO34887xAYIFcueaOwzty5To+KzzceQwcCCdP0mDNGj7+eSVzZm/k7Zg23NG7CN3KfMCATjsp2a6+06OrRg1nZMwHWGv58MMPqVKlCh06dOD555/XnYMiIn7GD26Sz75HFz4KwOzbZufqdVfuXXlmjZZfCw2FNm0IaNOGmx+Ga3bHMWnUfqZ93Zl5049y49zvua3ko1Qrd8IJW82aOY9KlVyZVzxy5AgDBgxg6tSp9OnThw4dOihgiYj4Id/4334flpzyz5RUxWK504n7oVYPAWTaKsLfFa1UgocmhjN9WQU6DavN1xX60evUJww//h9++NFwYOREpz/XjTfCs886i+v378+V2n755RcaNWrE9OnTefHFF/nkk09y5boiIuJ7NJJ1AS3edxo11S5dO9eueVv9286sAZPMVa7sNJIfMiSY//ynOCtWtGJJYkuwSZTnbyLiNtFgxjIafPkR4YVGEnRFxX9GuZo0gbCwHK1n1apVtG3blooVK7J48WJat2594W8SEZF8SyErCyk25czz8dePz7XrBph/Bhh3HN5B1TDd6p+VEiXgtdcgMRG2bDHExhYgNrY8MbHlWZB4FSQkUPDYMepu3UaDtb/Q4KMviAgZRcm6lznTi82bQ6NGUPj8RrGeSE5OJjAwkMaNG/Piiy/Sr18/SpQokbM/pIiI5DkKWVnYdmjbmedhITk76nEhw1sOZ+zPY7ll+i3nNSyVjBUoAPXrO48+fZxj+/YZYmMLsW5dIdauLcNnm1ry8fFTEHeCiiv20nDxKiIKzqVB6DhqNC5GYIvUNV0NGzonvIAFCxYwdOhQvv32W6644gpGjBjh5Z9SRETyCoWsLKSFrA+6fJDr1+4T0YexPzud5K21Wjh9icqVg2uvdR4ACQmGTZtCWLs2hHXrSvNLTATz98bD0ROEfBtHvf+tp0Gh72lQ7AMimodQvG2EE7rq1oXAf264TUxM5Omnn2b06NHUq1eP+LzeKVVERHKcQlYWnvnR6ZsaUS4i169tjKFisYrsPbqXqeun0juid67XEHcqjsPxh/PVdGXBgs4gVcOGzmtrA/jzz8LExhYmNrYssaur8VFsPClHTsLsE1SeuZOGIcuJKDGNBs0LUe1f1dhZvhy9n3ySlStX0r9/f15//XVCQ0Pd/cFERMTnKGRl4u+Tf595nn6NVG6adNMkbvjsBl5b8VquhKzD8Ye59tNrM3wvv05ZGgMVKjiPTp0AgoiPL8qvvxZl7VpYF12BJSsimbs/AWafoPCMIxw8/Tg7E9fxwpV9Gdr2ekIPHnStXYSIiPguhSyc6bhzXfff61yo5GxlC5c983z9/vXUL1s/x6+xK24XPb7occHPNX2vaaZBy1rLkt+XELU3irX71pJiUwgrFEbhAoXpVrsbLS5vkdNle1VIiLO1YuPGwD2FsLYQmzefYPnyBPb9VotViyYQtPUQM9eWZFb/RKoW3EyD0j/RoHEQDTpeRuUb6hNwWdkLXkdERPI3hawLWHn/Slev/+SVTzJqySjunnU3i+9ZTGhw9qelDpw4wPBvh7Pp4Kbz3nvlX6/Qoeo/zTP3Ht1L16ldASdo/XLfLwQGBHIy6STfbf+OT2M/zbI7/Xfbv+O+xvcxoOmAbNftlrVrY7jtttsoWLAgq1evJjCwJidPwvp1ltifDhG7uCA/rK/GrPmnYW4yxYbton6ZKBpGQsTVZajfPZzQCrrbUETE3yhkZWDa+mlnnrs1VZime53ujFoyCoB2H7YDoFRoKb65/ZuLXgy/fv967p5193nHb613K4ObD84wwFUsVpEf/u8HOnzcAfinb1ia4MBgACoUrUDPuj0JKxRG6dDSVChagVOnT3H7V7fz/ur3SbEpDGqWt5qrWmt56623eOSRRyhdujQTJ04kMHXxe2goNG9haN6iFDxWipQU2LUjhXUL/yL2+yRi11Zk+YJC8E0KAY/tpUaZDUTUS6FB+5I06FqVy8NDNbsoIpLPKWRlIOqPKADua3yfy5U4VvRdQasPWp15/ffJv2k2qRkAX9zyBdXCqmX5/VPWTeG1Fa+ddez5q57nxvAbPbp+sYLFiLo/6sw1AbrW6krn8M40vKxhlkF0/PXjGfK/IUxeM5l7Iu8hJDjEo2u67ciRI9x1113MmTOHzp078+GHH1K6dOlMPx8QAFWrB1C1egW6DKgAwLG4ZNZ/vZPYBX8Ru/o03ywpxoyfDDy/ixLFU2hQJ4mINsVpeOPl1GkQTEje+E8jIiIeMhmtR/JlTZs2tdHRObMI+4cdPzBi4Qim9JhCzVI1/7nGe00BiLo/yudaJyQmJ9L6g7M7iWe0Vup0yml6Te/F70d+P3OscvHKvNHpDSoVr+T1OtP7fvv3PPbdYwAsu3cZBYMK5ur1L0ViYiJXX301vXr1YujQoTny5yDlVCI7vtnM2vl7WRd1ithdxdiVcBkYQ0BoCOHVT9OgZWEa/KssDRoFUr681tKLCBhjVllrm7pdh1w8jWSdI32Xd18LWAAFAgsQ3S+a5JTkM1N332z7hk41Op35zPyt88+0n0jzzR3fUDo085EYb7q66tVnnreZ3IZONTox8uqRrk/Fnuv06dOMGzeOvn37EhYWxuLFi89MD+aEgEIFqH5zBNVvjqA7wMmTHFkSy7qvdxH78wlitxVn7vpqfPH+EQgNpVS5YBo0K0jElSVo2CiAOnU86o8qIiI+QiHrHD/s+MHtEjwSGBDIzFtn0m1aN57+4WkalmvITVNuOu9zy/sup0Cgu7+ZA0wA0f2iz4wQfrPtG77Z9g3gTIWmrety0+7du7n99ttZsmQJhQsXZuDAgTkasDIUGkrx61rS9rqWtAWIiyN55Sp++3Yba5ceZd3uEsTOqMmP08tD4cIEFQ2hVoOCNGxVmIgGhgYNnGarIiLimxSyzvH4d48DzpojX5d+2u/cgJVTdyLmpOh+0RxPPM5VH1115lirD1rx1JVP0a1ON9fqmjVrFvfeey9JSUl8+umn3HHHHe4UUqIEgR2vIbzjNYQDt+zfD9HRHFo0i3U//U3sn2WIXVSDL7+vxechxaFwYcpeEUKDpgVp0AAaNIBatSDY/cwqIiJoTdZ5a7LSRltW3r/S56azMvLVr1+duftwXKdxtK3c1uWKPGOtPWshPcBdDe/izgZ35uo+kRMmTGDw4ME0adKEKVOmULNmzQt/kxushd27ITqa07+sYsuiP4ndfxmx8TVYRwR/Bl4OoYUpUCKU2vWDaNgQIiKc4JXFen0RyQO0JivvUshKF7Lik+K58sMrgfzb4dzXbD+8nV7Te513/F/V/sVDrR46qyFrTkrbD/KPP/5gwoQJPPPMMxTISwueUlLgt98gKgqiojiwYhvrDlUkNr4mscFN+DUlnKRCRSE0lAqXB54JXA0aQM2aEKQxbJE8QyEr71LISheyYv6K4b45TtsGhazc9fuR35m3ZR4frDl/M+52V7TjsTaPUa5I9hcgWWuZPHkys2fPZubMmd5fd5VbkpPh119h5UqIjiZx9Xo2HytP7KlwYkNbEZtSjwMppSE0hIKFAqhX75/QFREBYbk3eCgiF0khK+9SyEoXsrpM6cIfx/7g1WtfpUPVDjlyDbl4cafiuGvmXfxx7I/z3hvRZgS96p0/8uWJI0eO0L9/f6ZNm0aHDh2YMWMGJUrk007siYkQG3tmpMuuW8++xDBik+qwrkRb1hLJ5mMVSC4YAhgqVeKs0a4aNZzeXyLiPoWsvEshK13ISluPNaf3HCoUrZAj15DsSbEpjFk+hi82fHHee1N7TqVGyRoeneeXX36hd+/e/P7774wcOZLHHnss/4xieeLkSVi9+kzoYssWElKC+ZU6xJa5htigxsQeqcyhU6GAITSU80a7ihVz+4cQ8U8KWXmXQlZqyEqxKQz53xAOxR/SVKGPOhR/iI6fdjzv+Mc3f0y9svUy/b7Tp09Tp04dkpKS+Pzzz2ndunWmn/UbcXGwapUTuFauhN9/x1r4I6Q6seWvY12hZqw9Vo2tf4SSkuL0i6tS5Z/A1bCh81qjXSLep5CVdylkLRzBm9e/ydD/DT1zXCHL93295Wue++m5844vuHMBJUNKArBv3z5KlChBwYIF2bBhAxUrVsy/04PZldougpUrncf+/QDEl7qcjZU7sTa0FetO1SR2WyhHjjjfUqQI1K//z2hX/frOMRHJWQpZeZdf32NkcP4Pfc/RPS5XIherc3hnOod3ZuOBjdw35z4SkxMBzox0NY9vzoxRM7jrrrsYPXo09eplPtIlQNmycMMNziNdu4iQqCiaRH1Jk7j3AbCVKrO76TXEFm1DbEItYreGMGmS8y3GQLVqZ492Va6srYFExH/5dchKk34rnT4RfVysRC5W3TJ1Wd53OdZaPo39lHHLxvHHrD9YtXAVhSoUYn7h+fz43o/UKVOHvo360qZSG5/oMO/TjHHSUeXK0L37We0iTFQUlVdMo/LJD+kMEB7Oie4t2VCqHWsT67BuS0G++w5mznROVazYP4ErIsJZ5xXqWz1yRUS8RiGLf0a0AKqWqOpiJXKpjDG0LdqWtz56i31R+/hXr3/x95V/E1DAWTT064FfeWTBI2d9T8mQkrS7oh19G/WlfNHybpSdNwQEOM21ataEPn2cdhEbNzrruaKjKTx3Ks0TP6F5QADUq0dKj2bsvLwt607XIfbXYGJjYdmyf05Vo8Y/U4wNGkDFihrtEpH8SSELWLtv7ZnnO+J2uFiJZEd8fDx79+5lxowZdO/e/czx/Sf28+OOH5nx6wy2H95+5vih+EPM2jSLWZtmnTn2cKuHuanWTRQpoMVFmQoMdIalIiLg3nvPaxcR8MlHVEuZTLUCBejasCFc34yjdVqw/nRtYjcEEhsL8+fDl186pwsLO3u0q25dKFTI3R9RRCQn+PXC9x93/MijCx8969iHXT8kolxEjpxfvO/48eNMmzaNvn37ApCQkEDBggU9+t5Tp08xd/Nc3lv9HofjD5/3/r2N7mVA0wF5Ynsln5JBuwjAmSds0gSaNSOlcVN+MzVYtyGA2Fgno/3+u/OxwEAIDz+7fUT58hrtEv+lhe95l0LWOSFrXp95OdJZXLwvJiaG2267jS1bthATE0ODBg2ydb4Um8LYFWOZsn7KWccrFK3Ay/96mbpl6k+K4eUAACAASURBVGbr/H4rg3YRAJQoAU2bQrNm0KwZcUUrsW69ORO6NmyAU6ecj5YuffaC+tq1IS/tgiSSHQpZeZdC1jkha3nf5RQI1L/evsxay/jx43n00UcpXbo0//3vf7n66qtz9Bq7j+zmpaUvsXLvyjPHutTqQufwzjQu3zhHr+V39u//Z5QrXbsIypZ1Alfz5tCsGcml/r+9Ow+Psrr/Pv4+M5OV7CFAWEICyUAWCEuAALYBEYutWqVQkVIWKdRHkVIttv1Rf0K1V61axUprHxX1cQW1St21rYiAEAmyh5CELQESErInkzCZmfP8MQONsgXJbMn3dV25zMx95p5vjiH55NznPqcHRUXOwLVnD+zaBSdcmwAEBDiDVttV6nu4Z5tLIbxOQpb/kpDVJmSFBoTy+bzPO+Tcwn3mzJnDiy++yPXXX8/zzz9P9+7d3fp+hVWF/OqTX53d5ictLo07R93JmL5j3Pq+XUKb5SLOBq/aWuexhISzo1xkZUFUFFVVzsB1ZrQrP985JQygZ8+vT6g3m51hTAh/JyHLf0nIahOyZBFS//DWW29RWlrK4sWLUR6cqHPKcopHv3iUfx/6NwARQRE8MPEBxieM91gNnV6b5SLYts15mdFicR4zm51ha/RoGD4cunWjtdU55avtaNfJk87mgYHOSfRnLjMOHQqxsd770oT4tiRk+S8JWRKyfJ7NZuOBBx4gNjaWxYsXX/oFblbRVMHCdxdedBFbo8GI3WE/+3hO5hxS41KJCo7CoAwkRiViMphQKCytFoJMQUQERWBQBhzaIZPtz/jGchHs3OkcujIYnKErNNQ5Uz49HWbMgO7dqaj4b+DaswcKCqC11Xm6+HgYNAh693bO84qLc152TEyUifXCd0nI8l8SsiRk+bTS0lJmzpzJpk2bWLBgAU8//bS3SzqrurmaJ3Of5N3Cdz3+3tebr+fe8fcSGtDFVvZsu1zEvn3O9FRa6pzXZTRCTg786EfOS4yujRWtVmfQOnN58cAB52jXmUn1Zwwc6PxITIQxY5wjXxK8hC+QkOW/JGRJyPJZb7/9NvPnz6e1tZWnnnqKWbNmebuky6a1psHaQE1zDVa7lT0Ve/jjpj+iteamwTfRcLqBquYqzLFmth7bSkhACEHGIHaf3N2u8/cO7811ydcxc8hMIoMj3fzV+LCSEli3Dv75T6ircw5VBQVBTAw0Nzs/hgyB1FQYPBidnEKzDqa83LlQ6rFjUF4OR444J9dr7TzFddc5PxITvf0Fiq5MQpb/kpAlIcsnFRYWMnjwYEaMGMGaNWtITk72dkk+ZfVXq3kq76lzns/okcGo3qNIik7CZDAxvNdwYkNju87lR6sV1q+Hl14Cm825Y3Vzs3OU6/hxzu5ubTI5b0eMjHTu/RMU5BzaamnB0mDns2PJfHA8ky/rBuEICCKtTx03f+cUQ6f0JiG7NwHdu3CgFR4nIct/SchyhaxFoxcxd9jcDjmv+Paqq6uJiYkB4MMPP2TSpEkEyoJI56W1ZmPJRt4rfI8d5Tuoaa5hQPQAjtYd/dp8sPMZ0nMI9467l9S4VA9V6wO0dl4nLChwzu2qrnaGrvp6Z8AKCXEuNd/mv6cagvhkWzRv7x/E4XrnrHkjDvpH1JDY+zS9wpoIMGmMRo1SCqMRVEQ4caP6M+KGvvRLCZZLjuKKScjyX106ZH125LOz+9ltW7DNo3eqia/TWrN69WqWLFnCu+++2+HrXnUlrfZW9lXu45ntzxARFEHd6bqvrfd1Puk90qlurmZC/wmEBITg0A7CAsMwKAMJkQkEGgPpFtANo8GIyWBiQPSALrWenNZwMK+Gog0nOLSniYMFrRwpC6SiOQK7Vji0wuFQ6FYbnN1wXhEdYWfooBYys0PJnBLPwKxoQkPPThcTol0kZPkv2bvQRQKW99TW1vLzn/+c119/nWuuuYbBgwd7uyS/FmAMYFivYfz1B3+9YJvDNYf56ds/pcXmnP29r2IfwDmr3V8uo8FIUlQSLbYWaltqabQ2nn0+0BjIDeYbMBlMpMSkkHs8l+y+2YzuM5qYkBhMBt/9caQUJI+KJnlU9EXbaQ26rp4jnxxg178r2bXdzu494WzYFgpPloGpEoKDCQkPoFtMEH1SQkgZEkJysnP/7YEDnVc4hRCdg4xkuUayZD6Wd2zdupVbb72V0tJSHnzwQe69914M8me+R2mtsbRaqDtdh81ho7allprmGsKDwik4VUCLrYVGayMtthZSYlJ4v+h9TjScoKKp4pxzBRoDsdqtHVbb3WPvJjQgFId2EBoQSrApmNqWWqKCozhlOUXv8N5EBEUQGhCK1W7F5rARYgohPCicqOAo3xhta22l+stidn90gtK9tVhKq2mqaKLRFkxpa0+KHANpDIxxXaYMIT4xiORBRlJSIDnZ+dG/v3NameiaZCTLf/nun46iS9i6dSsAmzZtIjs728vVdE1KKboFdqNbYDcAEiITzh473xZCN6fefFnnd2gHVruViqaKsyFOoShrLGP3yd2EBYbxws4Xzvvax7Y8dlnvdTEJkQmU1JUwIn4Es4bOIjkmmV5hvdx/U0BAADHjU5kwvs38t5YW53oSX36JPrSVk18dp/hYEEWWBIp3JlC0dzBf6ATsAcFgCiAgUJHUr9U54pUeRPKQEFIGGYiNlWUmhPBlMpIlI1keV15ezoEDB8jJyUFrTWNjI+Hh4d4uS/iYFlsLB6sPctp+mpONJ6loqsCu7VjtVhqtjUQHRxNoDKSouogB0QMIMYVgMpioP13PjvId2By2S85FO+PM6v2j+ozy3uhXdbVz7a99+yA/H2vebo7Ux1B8uh/Fp/tS3NKPotP9qLRFO5NVYCCR4Q5SEqykmBUpmaGkZMcyIDOcoCDvfAnCPWQky39JyJKQ5VEfffQRs2fPJiAggEOHDhEkvw2EB1ntVoqqiiisKuQPG//A2L5j2XJsyzntAo2BLBy5kB+n/9h7C77a7c67IZuanMtQtLRAXR11pfUU7ztNcYGNoiMmiisiKG7uS4t2hkOD0UBCTAPmfi3ExAeRMTyAhGEx9MvqSXhcsHe+FnFFJGT5LwlZErI8wmq1smzZMh599FEyMjJYu3YtaWlp3i5LCABK6kp4effLvLX/rfMeT4pO4jsJ3yGjRwbj+o0j2ORDYcVux1F6nGPbT1L8VT2F+1opOmwkt7Q3Lae/fi0xKsRKcs8GIuMC6JkYyrWzepA6oSdGk1xz9GUSsvyXhCwJWW7X2NjIxIkTycvL44477uDRRx8lJCTE22UJcUHVzdU8te0pKpoq2Fy6+YLtpqZO5ZTlFN/t/10SoxIxx5p9aqsja62FY9tPUrKjipL8Rg4fdHD0uImCyhisNudctNAgB8NTGsgaF0TWTX0Z9J0essSEj5GQ5b8kZEnI8ojFixczceJEbr758iZNC+ELLK0WNpdsJvd4LusK1rXrNeZYM6N6jyKzVyZ9wvswMGag7yxToTXVO46y/e2j5H1uIW9/GEebnIuthofYGJ7SRNb4ILJu7kfy2DgJXV4mIct/SciSkOUWjY2N3HPPPSxevJj09HRvlyNEh7M77NSdrqO0rpSyxjLePfAueyv30mRtavc5enTrAcBPhvyEiUkT6dGth3eCmMNBZd5Rtq8rJW+jhbyCMI5ZnDsvRIa2MnJQE1nfCSbr5gSSRnWXOxo9TEKW/5KQJSGrw+3cuZMZM2ZQWFjI3/72N26//XZvlySEVzRZm9hetp3PjnzGOwfewRxrprCqsF2vHddvHDn9c0jvkU6vsF5EBUe5udo2HA5O5h4h7+1S8ja1kFcYQVmzc7/GmG5WslKbyPpOCFk/6k+/YbESutxMQpb/cmvIUkpNAZ4AjMCzWuuHvnH8buBngA2oBG7TWh+92DklZPkurTVPPvkkS5cupXv37rzyyitMmDDB22UJ4bMc2sHeir386+C/CDAGkHcij/zK/Au2HxA9gGsHXsvszNmeXWrC4eDE5sPkrTtG3ubT5BVFUNESAUBceAtZqRaycrqRNS2R3unREro6mIQs/+W2kKWUMgKFwGTgGLANuFVrnd+mzUQgV2ttUUr9H2CC1vqWi51XQpbvevbZZ1mwYAHXX389zz//PN27d/d2SUL4JYd2kHssl/2n9rOzfOfZ578o/eLs51HBUYzvN56U2BQigiLoG9GXqOAo+kb0dXsA03YHpRsOkffP4+RtsZJXFEW11bmYba+IZrLSLGRNCCNrWiK9Ui++FZG4NAlZ/sudF/9HA8Va60MASqk1wA+BsyFLa72+TfutwCw31nMOhfy51REsFguhoaH89Kc/JSgoiFmzZslekEJcAYMyMLbfWMb2G/u15x3awUfFH/HYlseobanl/aL3oejc14cEhBAWGEZlUyUBxgB+mf1LhvUaRnJMcoescK+MBhKuTibh6mSmAtpm5/B/DpH3zgnytraycXs0720NgofK6BNVTFZ6C1kTw8malkhcigcvewrhZe4cyZoGTNFa/8z1+KfAGK31ogu0XwWUa60fvNh5O3Ika8ORDdzzyT2AjGR9GzabjRUrVvDqq6+yfft2oqLkh6cQnlTZVMmR2iM0tTbRYmuhsKqQTSWbCAkIIb8yn/P9fA8NCGVU71Fcl3IdExMnYjR0/KaIjlY7Bz85SN575eRttfHV4SgaWp1riyVENzJqiDN0jfzxQGISIzr8/TsbGcnyXz5xP7FSahaQBeRc4PhCYCFAQkLC+ZoIDyspKWHmzJls3ryZuXPnYjL5xLeSEF1KXLc44rrFnX08JXkKi8cs/lqb+tP1FFUVsaN8B4VVhXx6+FM2HN3AhqMbzrYZ2nMod4+9m9TuqR0SugwBRlJ+YCblB2ZuBRxWG4UfHiTv/XLycu18+EUM//g8EFYcY0BsPVlDrWRNimTktCQi+0noEp2HO0eyxgLLtdbfcz3+LYDW+o/faHcN8CSQo7WuuNR5ZSTL+9566y3mz5+P3W7n73//OzNnzvR2SUKIy1DRVMGu8l28X/Q+m0o2fe1YaEAo2X2zqW2pPbvCvTnWTERQx4Ufe0srBe8fJO+DCrZ96WDn0Wha7AEoICWulqxMK1nXRDP8RwMI7y37mspIlv9yZ8gy4Zz4Pgk4jnPi+0yt9b42bYYDb+K8rHiemQXnkpDlXVprJk+eTF1dHWvWrGHgwIHeLkkIcYWKqor4qPgjmlqbqGyq5GjdUY7UHjmnXXJMMt8b+D0mJE6gZ1jPDlvdvrXJSv57h8j7oIK8PM2ukhisDiMGpRnUo4asTBtZk6MZPj2Z0LhuHfKe/kRClv9y9xIO3wdW4lzC4Tmt9R+UUr8H8rTW7yil/g0MAcpcLynRWt94sXNKyPKO/Px8oqOjiY+Pp6qqivDwcAIDPXgLuRDCo2wOGycaTrCvYh9fHv+SouoiyhrLqGupu+BrYkJiaLG1MCNjBgC9w3szus9oooKjLiuQWRut7P3nQfI+rCRvO+w5Fk2rK3QN7llDmtmOeWgwKWO7kzyhLyFRnXujeQlZ/qtLL0YqIevStNY8++yz/OIXv+DGG29kzZo13i5JCOElWmsO1x4m70Qeb+a/Sd3pOiKDIjlUc6hdrw80BpIck0x+ZT4JkQkMiB7A+H7jCQ8KJyYkhqSoJCKDI8+5A7Kl7jS71x0i76NT7NyhOVAWQZPN+UeeAvpFNWBOaMGcaiRlZATmnHh6pHVHGTrHXc4SsvyXzFYWF1RbW8vChQt54403uOaaa1i5cqW3SxJCeJFSigHRAxgQPYAfp//4vG1sDhvVzdUUnCrgvcL3GN5rOG8VvMXhmsP0CutFaX0pACV1JZTUlfDZkc8u+p7ZfbMJNgUTmRjJ1CemMicqkVBjCGU7yinaWE7h9gaKDjgoOBzCv3dHwFqASiICj5ES34A5WZMyNISUcXEM/G4fAsNkBF54joxkyUjWee3bt4/rr7+eY8eO8eCDD7J06VIMskusEKKDWO1WKpsqOdl0kiO1R/i4+GNiQ2MxGUwcqT1yduX7Ht16UNF07j1RvcJ6Ud5YTkxIDBMSJzCq9ygSVQJN2+wU59ZSuOc0RYdNFFVE0GIPAMCgNInR9aT0t2JOM5KSFYV5Yh9ik317lXoZyfJfMpIlzqt3794kJiby2muvkZ2d7e1yhBCdTKAxkD4RfegT0YcR8SOYmjr1gm2brE0cqDrAnpN7KKkroayxjEpLJQDVzdW8tf8t3tr/1n9fMNj5MaTnEFIcMF5dReX+Jgx7+1G+P5KdhWF8vCMMXgEoIzr4MCm9GzGngHlYKCnje5A0vjemYPkVKa5Ml/4Osmu7t0vwKWVlZTz00EM88sgjREdHs379+ku/SAgh3KxbYDdGxI9gRPyIc45Z7VaO1h7lcO1hCk4V8FHxR2dHvvac3OP8L3sgFudKjK7VGEN0MFXVtcTW98Vxog9f1Bp5296E3hpMwH9iCWyJYpC1HyOi4klNCyVllHPUK6p/pIe+atEZdOmQ1Wpv9XYJPuOjjz5i9uzZNDY2cuutt8rolRDCLwQaA0mJTSElNoVrB177tcVYtdaU1pdS1lDG9rLtAGw7sY09J/cQH9ObZtVCc+wpuqWDyXKKREMALfUtNDW00GJxkHcaNluN2BwGwt8YjXotAN2zkOzyH/CdmAyGZMaRclVP+o/tjcEk0ynEubp0yHJoh7dL8Dqr1cr//M//8Oc//5khQ4awZs0a0tLSvF2WEEJcMaUUCZEJJEQmMKbvmHa/zqEd7K/cz+6Tu/nrtr/S2NREcP8DnGyo4nSL5vOIZ/mX3QglCvVSAKbnQolrjSEhII4BcXF8f+QwfjhtOgZjl/4VK5CQBcDoPqO9XIn3zJ8/n5dffpk77riDRx99lJCQEG+XJIQQXmVQBtJ7pJPeI51bh9x69nmtNScaTrDl2Ba2Hd1G/bFG9h0r5HhTBXWtVWxrPcjWBgOvf/ohJVOmEylXFru8Lh2yzszJ6tmtp5cr8TybzYbJZOLXv/41U6dO5eabb/Z2SUII4dOUUvSJ6MO0tGlMS5t2znG73c62TUUcP1ZIZGSX/vUqXLr0d4Hd4QxZ7tiF3lc1NjZy5513opTihRdeICMjg4yMDG+XJYQQfs9oNJKd47q1UQigS8/Ua3U4J75XNlV6uRLP+OqrrxgxYgQvv/wy/fv3x+GQOWlCCCGEu3TpkNVwugGA4ppiL1fiXlprVq5cydixY7FYLHz66aesWLFCFhcVQggh3KhLXy7sFujczX1C/wneLcTNysvLWbFiBd/73vd47rnn6N69u7dLEkII4Ue2b9/ew2QyPQtk0MUHaNpwAHttNtvPRo4cee62BHTxkHXm7sJvbkbaWezYsYNhw4YRHx/Ptm3bGDhwIMqX944QQgjhk0wm07O9evVKjYuLqzEYDP61H5+bOBwOVVlZmVZeXv4scOP52nTOdNFOZ/Zt7GzBw2azcd999zFy5Eiee+45AJKTkzvd1ymEEMJjMuLi4uolYP2XwWDQcXFxdThH985LRrLoXCNZJSUlzJw5k82bNzNv3jxuueUWb5ckhBDC/xkkYJ3L1ScXDBGdJ118Cxrn90tnCVnvvfcemZmZ7N69m1dffZXnnnuOsLAwb5clhBBCeFSfPn2GlJWVeX0gyesFeNOZkSxF57iMFhoayqBBg3jllVcYOHCgt8sRQgghurTOMYTzLXWGy4X5+fn8/e9/B+Dqq69my5YtErCEEEJ0Khs2bAg1m81pFotF1dfXG5KTk9Nzc3NDZs2alZCUlJQ+bty4lJycnOTnn38++sxrVqxY0ctsNqcNGTIkde/evUHeqLtLj2T588R3rTXPPPMMS5YsITIykpkzZxIREeGXX4sQQgg/cv/9PSksDO7Qc5rNLaxYcfJCh3NycixTpkypXbJkSZ/m5mbD9OnTq/Lz84NLS0sDi4uL9x0/ftyUkZGRMXfu3Kozr4mMjLQVFhbmr1q1Kvauu+7qt379eo8vium/QzgdwF9Hsmpra7nlllv4+c9/zvjx49mxYwcRERHeLksIIYRwm4cffrhsw4YNEbt27Qp94IEHyjdu3Bg2derUGqPRSEJCgi07O7uhbfs5c+ZUAyxYsKB6x44dXpmg3LVHslwT3/1pTpbVamXMmDEcOnSIhx56iKVLl8rK7UIIITznIiNO7nTy5EmTxWIx2Gw2ZbFYLvmLr+3vRqWUV+6M7NK/nf3pcuGZWgMDA/nNb37Dpk2b+PWvfy0BSwghRJcwb968/suWLTsxbdq0qkWLFvW96qqrGtetWxdtt9spLS015ebmhrdt/+KLL8YArF69Onr48OFN3qi5S49k+cvdhSdOnGD27NnccccdTJ06lXnz5nm7JCGEEMJjVq1aFRsQEKBvv/32apvNxogRIwZPmzatJj4+3pqcnJweHx9vTU9Pt0RFRdnPvKampsZoNpvTAgMD9Zo1aw55o+4uHbL8YZ2sDz74gDlz5tDU1MTcuXO9XY4QQgjhcYsWLapatGhRFYDJZGL37t0FADk5OU2RkZGO8vJy46hRo1JHjhxpATh+/Pge10uPe6lkoKuHLB++XHj69Gl++9vf8vjjjzN06FDWrFlDamqqt8sSQgghfMbkyZNT6uvrja2trWrp0qVlCQkJNm/X1FaXDlm+fLnwww8/5PHHH+fOO+/k0UcfJTi4Y++WFUIIIfzdl19+ecDbNVxMlw5Zvni58NChQwwYMICbbrqJbdu2kZWV5e2ShBBCCPEt+E668AJfulzY2NjInDlzyMjIoKioCEAClhBCCOHHZCQL718u/Oqrr5gxYwYHDx7kvvvuIykpyav1CCGEEOLKdemRrLNzsrw4kvXEE0+QnZ2NxWLh008/Zfny5ZhMXTr7CiGEEJ1Clw5ZZ3hzTtaRI0e47rrr2LVrFzk5OV6rQwghhOhqRo8ePejzzz8Pddf5u/SQSZAx6Gv/9ZT169cTGhrKmDFjeOSRRzAajT4xL0wIIYQQYLPZOuSqUpceyZo/Yj4LRy7kh4N/6JH3s9ls3HfffUyaNInly5cDzkXVJGAJIYQQF7Zhw4ZQs9mcZrFYVH19vSE5OTk9Nzc3ZNasWQlJSUnp48aNS8nJyUl+/vnnowHWrl0bmZSUlJ6enp46d+7cfhMnTky+1HuEhoYOX7BgQd9Bgwal/ec//+mQDaW79EhWsCmYhSMXeuS9jh49ysyZM/niiy+47bbb+Mtf/uKR9xVCCCE60v3307OwkA5dvNFspmXFCi648XROTo5lypQptUuWLOnT3NxsmD59elV+fn5waWlpYHFx8b7jx4+bMjIyMubOnVtlsVjUL37xi/6fffZZweDBg6033HBDu+4ma25uNowZM6bpmWeeOdZRX1eXHsnylP379zNs2DD27NnDq6++yurVq+nWrZu3yxJCCCH8xsMPP1y2YcOGiF27doU+8MAD5Rs3bgybOnVqjdFoJCEhwZadnd0AsHPnzuB+/fqdHjx4sBVgxowZ1e05v9FoZO7cuTUdWXOXHsnyFLPZzJw5c7jrrrsYOHCgt8sRQgghvrWLjTi508mTJ00Wi8Vgs9mUxWL5VoNEV111VcqpU6cCMjMzm9auXXu07bHAwEBHR9/dLyNZbrJv3z6uvvpqysrKMBqNrFy5UgKWEEII8S3Nmzev/7Jly05MmzatatGiRX2vuuqqxnXr1kXb7XZKS0tNubm54QBDhw5tKS0tDTpw4EAgwNq1a2POnGPTpk1FBQUF+d8MWO4iI1kdTGvN008/zZIlS4iIiODo0aPEx8d7uywhhBDCb61atSo2ICBA33777dU2m40RI0YMnjZtWk18fLw1OTk5PT4+3pqenm6Jioqyh4WF6ccee+zolClTUkJDQx2ZmZlN3qpbndlaxl9kZWXpvLw8b5dxXjU1NSxYsIB//OMfTJ48mRdffJFevXp5uywhhBB+TCm1XWvt1X3Wdu3adSQzM/OUN2s4n7q6OkNkZKSjvLzcOGrUqNTNmzcXJCQk2M4873A4mD17dkJKSkrL/fffX+GOGnbt2tU9MzMz8XzHZCSrA/3ud7/jn//8J3/605/41a9+hcEgV2OFEEIId5k8eXJKfX29sbW1VS1durQsISHBBrBy5crur732WvfW1laVnp5uufvuu70SEGUk6wrZ7XZqamro3r07NTU1FBUVMXr0aG+XJYQQopOQkSzfdrGRLBlquQInTpzg2muvZcqUKbS2thIdHS0BSwghhBCAhKxv7f333yczM5OtW7dyxx13yKbOQgghhPgaCVmX6fTp09x9991cf/319O7dm7y8PG677TbZGkcIIYQQXyMh6zLZ7XY++eQTFi1aRG5uLqmpqd4uSQghhBA+SEJWO7355ps0NjYSGhpKbm4uTz75JMHBHbp1kxBCCCE6QJ8+fYaUlZVdch7Phdo1NDQYJkyYkJyUlJSenJycfscdd/T5NnVIyLqEhoYGZs+ezfTp01m1ahWA7DsohBBCdFIOhwOAe+655+Thw4f37d27Nz83Nzfs9ddfj7jcc0nIuoivvvqKkSNH8sorr7B8+XKWLl3q7ZKEEEKILmfDhg2hZrM5zWKxqPr6ekNycnJ6bm5uyKxZsxKSkpLSx40bl5KTk5P8/PPPR595zYoVK3qZzea0IUOGpO7duzfoYuc/cOBAYGJiYsbNN9+caDab08vKykw33HBDA0BwcLAeOnSopbS0NPBy65Zb4i7gjTfe4Cc/+Qk9evRg/fr1fPe73/V2SUIIIYTX3b/+/p6FVYUdOl/GHGtuWTFxxQU3ns7JybFMmTKldsmSJX2am5sN06dPr8rPzw8uLS0NLC4u3nf8+HFTRkZGxty5c6vOvCYyMtJWWFiYv2rVqti77rqr3/r164svVkNJSUnQ6tWrD0+aNOlI2+dPnTpl/Ne//hW1dOnSy94YW0ayLmDUqFHccsst7Nq1SwKWEEII4WUPcRTReQAACwlJREFUP/xw2YYNGyJ27doV+sADD5Rv3LgxbOrUqTVGo5GEhARbdnZ2Q9v2c+bMqQZYsGBB9Y4dO8Iudf74+HjrpEmTvrbPYWtrK1OnTh2wcOHCk2lpadbLrVlGstr49NNPefXVV3nmmWdITEzkpZde8nZJQgghhE+52IiTO508edJksVgMNptNWSyWSw4Std3aTimlbTYbGRkZaQBTpkypXbly5Ym27UNDQx3fPMfMmTMTBwwY0PK///u/32rfQ7eOZCmlpiilDiilipVSvznP8SCl1FrX8VylVKI767mQ1tZWli1bxjXXXMPmzZuprKz0RhlCCCGEuIB58+b1X7Zs2Ylp06ZVLVq0qO9VV13VuG7dumi73U5paakpNzc3vG37F198MQZg9erV0cOHD28ymUwUFBTkFxQU5H8zYJ3P4sWLe9fX1xtXr15d+m1rdttIllLKCPwVmAwcA7Yppd7RWue3aTYfqNFaJyulZgB/Am5xV03nc+TIEWbOnMmWLVuYP38+TzzxhNw9KIQQQviQVatWxQYEBOjbb7+92mazMWLEiMHTpk2riY+PtyYnJ6fHx8db09PTLVFRUfYzr6mpqTGazea0wMBAvWbNmkOX834HDx4MePLJJ+OTkpJa0tPT0wAWLlxYcbkbTbttg2il1Fhgudb6e67HvwXQWv+xTZuPXW22KKVMQDkQpy9SVEduEO1wOMjIyODYsWM8/fTTzJgxo0POK4QQQnQU2SD6wurq6gyRkZGO8vJy46hRo1I3b95ckJCQYPNkDRfbINqdc7L6AG2H2I4BYy7URmttU0rVAbHA1/5HKqUWAgsBEhISOqxAg8HA6tWr6dmzJwMGDOiw8wohhBDC/SZPnpxSX19vbG1tVUuXLi3zdMC6FL+Y+K61fhp4GpwjWR157rFjx3bk6YQQQgjhIV9++eUBb9dwMe6c+H4c6NfmcV/Xc+dt47pcGAlUIYQQQgjh59wZsrYBKUqpJKVUIDADeOcbbd4B5rg+nwZ8erH5WEIIIYTwCofD4VDeLsLXuPrknKUfznBbyNJa24BFwMfAfuB1rfU+pdTvlVI3upqtBmKVUsXA3cA5yzwIIYQQwuv2VlZWRkrQ+i+Hw6EqKysjgb0XauPWOVla6w+AD77x3P+2+bwFmO7OGoQQQghxZWw228/Ky8ufLS8vz0B2iznDAey12Ww/u1ADv5j4LoQQQgjvGTlyZAVw4yUbiq+RNCqEEEII4QYSsoQQQggh3EBClhBCCCGEG0jIEkIIIYRwAwlZQgghhBBuICFLCCGEEMINJGQJIYQQQriBhCwhhBBCCDdQ/rZVoFKqEjjagafsDpzqwPN1VdKPV0768MpJH1456cMr19F92F9rHdeB5xMe4nchq6MppfK01lnersPfST9eOenDKyd9eOWkD6+c9KE4Qy4XCiGEEEK4gYQsIYQQQgg3kJAFT3u7gE5C+vHKSR9eOenDKyd9eOWkDwUgc7KEEEIIIdxCRrKEEEIIIdygy4QspdQUpdQBpVSxUuo35zkepJRa6zqeq5RK9HyVvq0dfXi3UipfKbVbKfUfpVR/b9Tpyy7Vh23a/UgppZVScofSebSnH5VSP3Z9P+5TSr3q6Rp9XTv+PScopdYrpXa4/k1/3xt1+iql1HNKqQql1N4LHFdKqb+4+ne3UmqEp2sU3tclQpZSygj8FbgOSANuVUqlfaPZfKBGa50MPA78ybNV+rZ29uEOIEtrPRR4E3jYs1X6tnb2IUqpcOAXQK5nK/QP7elHpVQK8FtgvNY6HVji8UJ9WDu/F38HvK61Hg7MAP7m2Sp93gvAlIscvw5IcX0sBJ7yQE3Cx3SJkAWMBoq11oe01lZgDfDDb7T5IfD/XJ+/CUxSSikP1ujrLtmHWuv1WmuL6+FWoK+Ha/R17fk+BHgAZ8hv8WRxfqQ9/bgA+KvWugZAa13h4Rp9XXv6UAMRrs8jgRMerM/naa0/B6ov0uSHwIvaaSsQpZSK90x1wld0lZDVByht8/iY67nzttFa24A6INYj1fmH9vRhW/OBD91akf+5ZB+6Lin001q/78nC/Ex7vhfNgFkptVkptVUpdbERh66oPX24HJillDoGfADc5ZnSOo3L/ZkpOiGTtwsQnY9SahaQBeR4uxZ/opQyAI8Bc71cSmdgwnmZZgLOEdXPlVJDtNa1Xq3Kv9wKvKC1/rNSaizwklIqQ2vt8HZhQviLrjKSdRzo1+ZxX9dz522jlDLhHB6v8kh1/qE9fYhS6hpgGXCj1vq0h2rzF5fqw3AgA/hMKXUEyAbekcnv52jP9+Ix4B2tdavW+jBQiDN0Caf29OF84HUArfUWIBjnnnyifdr1M1N0bl0lZG0DUpRSSUqpQJyTON/5Rpt3gDmuz6cBn2pZRKytS/ahUmo48H9xBiyZA3Oui/ah1rpOa91da52otU7EOa/tRq11nnfK9Vnt+fe8DucoFkqp7jgvHx7yZJE+rj19WAJMAlBKpeIMWZUerdK/vQPMdt1lmA3Uaa3LvF2U8KwucblQa21TSi0CPgaMwHNa631Kqd8DeVrrd4DVOIfDi3FOZpzhvYp9Tzv78BEgDHjDdc9Aidb6Rq8V7WPa2YfiEtrZjx8D1yql8gE7sFRrLSPTLu3sw3uAZ5RSv8Q5CX6u/OH5X0qp13AG+e6ueWv3AwEAWuu/45zH9n2gGLAA87xTqfAmWfFdCCGEEMINusrlQiGEEEIIj5KQJYQQQgjhBhKyhBBCCCHcQEKWEEIIIYQbSMgSQgghhHADCVlC+DGllF0ptVMptVcp9a5SKqqDzz9XKbXK9flypdSvztNmuVLquKuOfKXUre04703n2xxbCCE6EwlZQvi3Zq31MK11Bs713e70Uh2Pa62H4dwU9/8qpQIu0f4mQEKWEKJTk5AlROexhTYb0CqlliqltimldiulVrR5frbruV1KqZdcz92glMpVSu1QSv1bKdXz2xSgtS7CufBitOu8C1w17FJK/UMpFaqUGgfcCDziGv0a6Pr4SCm1XSm1USk1+Ar6QQghfEKXWPFdiM5OKWXEuQXKatfja3Hu1TcaUDj3QPwuzv04fweM01qfUkrFuE6xCcjWWmul1M+Ae3Gu+H25dYwAitpsq/SW1voZ17EHgfla6yeVUu8A72mt33Qd+w9wu9a6SCk1BvgbcPXl94QQQvgOCVlC+LcQpdROnCNY+4F/uZ6/1vWxw/U4DGfoygTe0FqfAtBaV7uO9wXWKqXigUDg8GXW8Uul1DycewTe0Ob5DFe4inLV8PE3X6iUCgPG8d/tmACCLvP9hRDC58jlQiH8W7NrLlR/nCNWZ+ZkKeCPrvlaw7TWyVrr1Rc5z5PAKq31EODnODcDvhyPa63TgR8Bq5VSZ17/ArDIdd4VFzivAahtU+swrXXqZb6/EEL4HAlZQnQCWmsLsBi4RyllwjlidJtrlAilVB+lVA/gU2C6UirW9fyZy4WRwHHX53OuoI53gLw25wgHylwT4X/SpmmD6xha63rgsFJquqsmpZTK/LY1CCGEr5CQJUQnobXeAewGbtVafwK8CmxRSu0B3gTCtdb7gD8AG5RSu4DHXC9fjvNy3Xbg1BWW8nvgbqWUAbgPyAU2AwVt2qwBlrom2g/EGcDmu2rah/MuRSGE8GtKa+3tGoQQQgghOh0ZyRJCCCGEcAMJWUIIIYQQbiAhSwghhBDCDSRkCSGEEEK4gYQsIYQQQgg3kJAlhBBCCOEGErKEEEIIIdxAQpYQQgghhBv8fwbYx8whsH/vAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "\n",
    "plt.plot(recall_xgb, precision_xgb, label = 'xgb', alpha = 0.8, color = 'red')\n",
    "plt.plot(recall_lr, precision_lr, label = 'xgg-lr', alpha = 0.8, color = 'blue')\n",
    "plt.plot(recall_lr2, precision_lr2, label = 'xgb-lr2', alpha = 0.8, color = 'green')\n",
    "\n",
    "plt.plot([0,1],[0,1],'k--')\n",
    "\n",
    "#图例打印\n",
    "plt.legend(bbox_to_anchor=(1.05, 0), loc = 3, borderaxespad = 1)\n",
    "\n",
    "plt.xlim([-0.05, 1.05])\n",
    "plt.ylim([-0.05, 1.05])\n",
    "\n",
    "plt.xlabel('Recall Rate')\n",
    "plt.ylabel('Precision Rate')\n",
    "plt.title('PR Curve')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
